<!DOCTYPE html>
<html>
<head>
	<title>复习</title>
<!-- 
基本数据类型
number boolean string null undefined
Array Object Function
隐式类型转换和强制类型转换
  隐式类型转换
  + - * / %（number）   
  ""（String）注意拼串
  注意：任何数加undefined都是NaN
  		任何数字减undefined都是NaN（包括字符串）
  		"120"*20   2400
  强制类型转换,
	Number() Boolean() String()

循环语句
	for(){}
	while(){}
	do{}while{}
	for( in )遍历数组对象
	forEach()回调函数 ie8以下兼容

判断语句
	if(){}else{}
	switch(){}
	三元运算符 ... ? .. : .. ;

跳转语句
	break 终止当前循环
	continue//肯替牛 //跳出当前循环

等号
 	= 赋值
 	==值相等（判断值）
 	===全等（类型和值）

弹窗 //要记下来啊
	document.write()
	alert
	confirm
	prompt
对象Object  //对象字面量创建才是 : ,
	创建对象的方法
	1·构造函数创建
		var obj= new Object();
		obj.name = name;
		obj.age = age;
		...  ...
	2·字面量创建
		var obj = {
		name:name,
		age:age
		}
	更改对象属性
		obj.name = "新属性值"
		删除对象属性
		delete obj.name 删除对象的name值

基本数据类型和引用数据类型行的区别
基本数据类型 一个具体的值
引用数据类型 可扩展的，改变的
存放区别 基本存放在栈 引用存放在堆
拷贝区别 基本深拷贝 引用浅拷贝

堆和栈的区别
	栈内存存放基本数据类型和变量
	堆内存存放对象

深浅拷贝
	一个对象复制另一个对象是，改变其中一个，另一个跟着改变的就是浅拷贝
	一个对象复制另一个对象是，改变其中一个，另一个不跟着改变的就是深拷贝
	（总感觉制作者把深浅弄反了）

数组方法：
	concat()合并数组

    push()向后添加一项或多项，返回添加完的新数组  

	shift()在前面删除一项，返回删除的项

	unshift()
	在前面添加一项或多项返回新数组和个数

	splice()删除并添加

	slice()截取指定的元素（下标）

	split()将字符串分割成数组//

	join()将字符串变成数组//

	pop()在后面删除一项或多项

	sort()对数组元素进行排序（unicode编码）//

	toString()将数组转化为字符串//

	indexOf()第一参数要找的值，第二个参数在那里开始
	从左到右查询数组中的项返回期索引值

	lastIndexOf()参数和上面一样的作用
	从右到左查询数组中的项返回值索引值

	reverse()颠倒数组中的顺序//

去重（至少会2种）
var arr= [41,2,4,1,2,5,1,2,15,121,2,15]
for(var i = 0; i<arr.length;i++){
	for(var j = i+1;j<arr.length;j++){
	if(arr[i]==arr[j]){
		arr.splice(j,1);
		j--;
	}
	}
}  //没记住啊
console.log(arr);
冒泡排序
var  arr1 = [1,2,5,1,0,4,5]
for (var i = 0; i < arr1.length-1; i++) {
	for (var j = 0; j < arr1.length-i-1; j++) {
		console.log(i);
		if (arr1[j]>arr1[j+1]) {
		var b = arr1[j];
		arr1[j] = arr1[j+1];
		arr1[j+1] = b;
	}
	}	
}
console.log(arr1);

构造函数
	用new关键字调用函数时，并且为了区分普通函数和构造函数通常构造函数的首字母大写调用函数时用new关键字调用函数关键
	1.new关键字调用
	2.首字母大写（与普通函数进行区分，不是必须）

	this指向
	1.普通函数调用，this指向window
	2.对象方法调用，this指向调用的对象
	3.构造函数调用时，this新创建的对象
	4.call、apply、bind可以改变this指向。this指向它们调用的对象。

call和apply的方法
	call和apply是函数方法
	call apply bind可以可以改变this指向
	call

内置对象：
Math方法
	Math.abs绝对值
	Math.round四舍五入
	Math.ceil向上取整
	Math.floor向下取整
	Math.random随机数（0~1的小数）

Date日期：//记记就得了
	var date = new Date();
	获取是get 设置是set
	getFullYear获取年份
	setFullYear设置年份
	getMonth()+1获取月份0~11
	setMonth 设置月份
	getDate 获取日期
	setDate 设置日期
	getDay 获取星期几
	setDay 设置星期几
	getHours  获取小时 0-23
	getMinutes	获取分钟 0-59
	getSeconds 获取秒 0-59


字符串的方法：//背     
1.split把字符串分割成数组
2.concat把合并字符串
3.indexOf查找字符串中的项（从左向右
  lastIndexOf 和上面一样 （从右向左
4.与正则匹配结合使用的字符串方法
  4个 search()math()split()replace()
	- seach()检索字符串返回索引，正则匹配结合使用，找到一个就不继续向下找了。即使正则匹配g。只找到一个就不找了
	- macth()匹配查找字符串中的项，将找得到的项作为数组项返回，即使是一项也以数组的形式返回。
	- split()分割字符串，可以结合正则多个字符串进行分割
	- replace()替换
		- 第一个参数是要替换的项
		- 第二个参数新项

DOM 
	1.获取元素的方式
	document.getElementById
	document.getElementsBy ClassName TagName Name
	document.querySelector("#id//.classname //标签")
	document.querySelectorAll()

	2.绑定事件的方式
		行内绑定 在标签上
		动态绑定 通过on
		事件监听 addEventListener
		可以解除监听，阻止默认事件
		第三个参数 true是事件捕获
				false是默认事件冒泡

	查找所有的文本节点
		childNodes 文本 空格 回车
	查找子节点
		children
	查找第一个子节点
		firstChild 	文本 空格 回车	
	查找第一个子元素
		firstElementChild 子元素
	查找最后一个子节点
		lastChild
	查找最后一个元素节点
		lastElementChild
	父节点
		parentNode 只有元素
	兄弟节点
		nextSibling下一个兄弟节点
		nextElementSibling
		previousSibling上一个兄弟节点
		previousElementSibling






	对元素属性进行更改
	<input type="text" name="suu" id=""> input.type = "更改后的属性"
	input.name = ''
	
	元素增删改查
	1.创建 元素 节点
	create Element

	节点增删改查
	createTextNode文本节点

	替换节点
	replaceChild()
	追加节点 （在后面追加）
	appendChild
	在中间或前面添加
	insertBefore(新节点在旧节点前面,旧节点)
	删除节点
	removeChild()

事件
	1.鼠标事件
		click 点击
		dblclick 双击
		mouseover 鼠标滑过
		mouseout 鼠标移出
		mouseleave 鼠标移开
	2.键盘事件
		key down
		key up
		key press
	3.表单事件
 -->
</head>
<body>

</body>
<script type="text/javascript">
//splice
//去重
//1.for循环嵌套 splice删除重复的项
//2.indexOf == -1 push添加到新数组
//3.sort结合回调函数排序然后删除重复的项
	// var arr= [1,2,4,1,2,3,1,2,5,1,2,45]
	// for(var i = 0; i<arr.length;i++){
	// 	for(var j = i+1;j<arr.length;j++){
	// 	if(arr[i]==arr[j]){
	// 		arr.splice(j,1);
	// 		j--;
	// 	}
	// 	}
	// }
	// console.log(arr);
//indexOf
 // var arr = [1,1,2,3,5,3,1,5,6,7,4];
 //            var res = [];
 //            for (var i = 0; i < arr.length; i++) {
 //            	if (res.indexOf(arr[i] )==-1) {//indexOf寻找不到会返回-1；寻找不到就添加
 //            		res.push(arr[i])
 //            	}
 //            }
 //        console.log(res);
//循环arr数组里的全部内容
//设置空数组
//在用indexOf寻找空数组里是否有arr中的第[i]项，有就跳过，没有push添加
	//ps：indexOf的第一个参数是要寻找的项，找不到会返回-1；
	//pss:indexOf里的o要大写O；

//3.sort   b a 
//           b a 
//             b a 
// var arr = [1,2,3,4,5,8,2,1,6];
// arr.sort(function(a,b){
// 	if (a>b) {
// 		return 1;
// 	}if (a<b) {
// 		return -1;
// 	}else{
// 		return 0;
// 	}
// })
//a-b升序
//b-a降序



//冒泡排序
//两个for循环嵌套，两个相邻的进行比较 比较 较大的于较小的互换位置，大的放后面，小的放前面

// var  arr1 = [1,2,5,1,0,4,5]
// for (var i = 0; i < arr1.length-1; i++) {
// 	for (var j = 0; j < arr1.length-i-1; j++) {
// 		if (arr1[j]>arr1[j+1]) {
// 		var b = arr1[j];
// 		arr1[j] = arr1[j+1];
// 		arr1[j+1] = b;
// 	}
// 	}	
// }
// console.log(arr1);

//函数 function
	// function fun(){
	// 	var a=1;
	// 	var b = 2;
	// 	var c = a+b;
	// 	console.log(c);
	// 	return console.log(d);
	// 	var d = a+c;
	// 	console.log(d);
	// }
	// fun();
	
//作用域
//全局作用域 局部作用域
//全局作用域在标签<script>里，页面打开全局作用域开启，页面关闭作用域销毁
//局部作用域在function里，函数调用时打开，函数执行完毕，局部作用域销毁


//全局变量和局部变量
//全局变量在全局中var声明的变量，还有在函数体内无var生命的变量。在全局和局部作用域中都能用
//在函数体内var声明的变量，只能在函数体内使用。
	// var a = 3;//全局
	// function fun(){
	// 	c = 4;//全局
	// 	var b = 2;//局部
	// 	console.log(a+b)
	// }
	// fun();
//console.log(a+b)//b没有定义

//this指向  4种
		// function aaa(){
		// 	console.log(this)
		// }
		// aaa()
		// var obj = {
		// 	name:"葛慧杰",
		// 	sayName:function(){
		// 		console.log(this);
		// 	}
		// }
		// obj.sayName();
	//构造函数调用时
	// var obj2 = new Person();
	// function Person(name,age,jj){
	// var obj3 = new Object();
	// this.name = name;
	// this.age = age;
	// this.height = jj;
	// return this;
	// }
	// var rel = new Person("景明居",150,13);
	// console.log(rel)
	


//while
	// var total=0;
	// var i=1;//var i=1
	// while(i<=100){//var i<=100
	//     total+=i;//1+0+2+0+3+0
	//     i++;//i++ while条件在此循环
	// }
	// alert(total);//大于
//do{}while()
	// var a = 1;
	// var c = 0;
	// do{
	// c=c+a;
	// }while(a=0)
	// console.log(c)

//for( in )
	// var x;
	// var arr6 = [1,2,45,2,8,1,6]; 
	// for(x in arr6)
	// console.log(arr6[x]);

//forEach()
	
//三元运算表达式
	// var i = 1;
	// if (i<=3) {
	// 	console.log(i);
	// }else{
	// 	console.log(i);
	// }

	// i==(1+2)?console.log(true):console.log+(i);

//call和apply都可以改变this指向
//第一个参数都是对象，区别是call传实参
//apply传实参必须放到数组中即使是一个实参也要放到数组中
function fun(a,b,c){
	console.log(a+b+c)
	return this;
}
var obj = {
	name:"苏子猪",
	age:2000
}
// var rel = fun.call(obj,2,3,4);
// console.log(rel);//返回obj
// var rel1 = fun.apply(obj,1,2,3);
// console.log(rel1);
// var rel3 = fun.bind(obj);
// console.log(rel3);//整个函数都返回了

// var a = new Date();
// var year = a.getFullYear();
// var month = a.getMonth()+1;
// var date = a.setDate(5);
// console.log(date);

addEventListener("keydown",function(e){
	var e = e||window.e
	console.log(e.keyCode);
})
// Math.random  
// document.getElementById()
// document.getElementsByTagName()
// document.getElementsByName()
// document.getElementsByClassName()
// document.querySelector()
// document.querySelectorAll()
// childNodes
// children //求准
// firstChild
// firstElementChild
// parentNode
// createElement
// createTextNode
// appendChild   //  
// removeChild
// previousSibling
// previousElementSibling
// replace
// search
// indexOf
// match
// addEventListener
// onkeydown
// splice
// concat
// switch
// unshift
// apply
// replaceChild

</script>
</html>